A Graphical User Interface (GUI) is an area of an electronic display surface, such as 129 in FIG. 1a, that allows users of an application to access various functions provided by an application. Typically, a GUI 130 will present a viewer with a plurality of items 131-144 in a tabular layout 150. These items 131-144 may be menu items or control buttons that provide specific application functions. For example, in FIG. 1, item 131 may provide a viewer with a drop-down menu allowing the viewer to open a new file, save a file, print a file, and so on. Item 135 may allow a user to bypass the drop-down menu and save a file with a single selection.
In the case of table 150, the layout of items 131-144 is determined by supporting processes that are accessed via an Application Programming Interface (API). A creator of a GUI can write code that is recognized by the API, and can thereby control the features of the resulting GUI. To facilitate the creation of such code, programmers may make use of a GUI development environment. A GUI development environment is an application that provides useful functions to assist in the creation of the code behind GUIs. Such a development environment is available in a variety of different products, such as the MICROSOFT® .NET framework. A GUI development environment may be an aspect of a larger integrated development environment (IDE), such as MICROSOFT'S VISUAL STUDIO®, BORLAND'S C++ BUILDER®, METROWERK'S CODE WARRIOR®, and IBM'S WEBSPHERE STUDIO®.
Almost all modern GUI development environments provide assistance in generating table layouts, sometimes also called grid layouts. An exemplary table layout in addition to 151 in FIG. 1a is provided in FIG. 1b. The table 115 comprises a plurality of items 100-110 that are positioned within the table 115. Traditionally, to initialize a table 115 for an application GUI, rows are added to the table, followed by adding cells to the rows, and finally adding items to the cells. In the case of creating a GUI using the Hyper Text Markup Language (HTML), this process is relatively easy. For example, the following is an example of the code necessary to create a simple, one row table with two items, or buttons, in HTML:
<table> <tr>  <td>Button1</td>  <td>Button2</td> </tr></table>
While HTML provides a convenient way to create tables in some settings, the typical application GUI, such as 130, is not defined in HTML. Instead, an application GUI 130 may be defined in code. The creation of the code for a GUI is not as simple as the HTML scenario. Consider, for example, the table with one row and two buttons from the HTML example above. In code, the creation of the same table with the same layout is more verbose and difficult to follow:
Table table = new Table( );// Create rowTableRow row1 = new TableRow( );// Create cellsTableCell cell1 = new TableCell( );TableCell cell2 = new TableCell( );// Add cells to rowrow1.Cells.Add(cell1);row1.Cells.Add(cell2);// Add controls to cellscell1.Add(new Button( ));cell2.Add(new Button( ));
As pointed out by the comments in the above example—comments are on lines preceded by two forward slashes—the creation of the GUI with two buttons in code involves a sequence of steps. These steps are illustrated in FIG. 1c. In general, the process involves first creating the table 120, then creating the row 121, then creating the cells 122, then adding the cells to the row 123, and finally adding items, also called controls or buttons, to the cells 124. As can also be seen in FIG. 1c, this process involves a deliberate creation of new rows and cells to accommodate new items. If additional items are desired for a table, then a new cell must be placed in the table if there is sufficient space in the row to accommodate the item. If there is not sufficient space, a new row must first be created, then a new cell, and so on. This deliberate creation of new locations for additional items is represented by the decision 126 in FIG. 1c. 
Using a variety of APIs available in the art, the code for the creation of a particular tabular layout may take a wide variety of forms. One popular API is the Grid Bag Layout API, also called the Grid Bag Layout Engine, provided by SUN MICROSYSTEMS®. Using the Grid Bag Layout API, the following code can be used to generate the layout shown in FIG. 1b:
protected void makebutton(String name,       GridBagLayout gridbag,       GridBagConstraints c) { Button button = new Button(name); gridbag.setConstraints(button, c); add(button);}public void init( ) { GridBagLayout gridbag = new GridBagLayout( ); GridBagConstraints c = new GridBagConstraints( ); setFont(new Font(“Helvetica”, Font.PLAIN, 14)); setLayout(gridbag); c.fill = GridBagConstraints.BOTH; c.weightx = 1.0; makebutton(“Button1”, gridbag, c); makebutton(“Button2”, gridbag, c); makebutton(“Button3”, gridbag, c); c.gridwidth = GridBagConstraints.REMAINDER; //end row makebutton(“Button4”, gridbag, c); c.weightx = 0.0;//reset to the default makebutton(“Button5”, gridbag, c); //another row c.gridwidth = GridBagConstraints.RELATIVE; //next-to-last in row makebutton(“Button6”, gridbag, c); c.gridwidth = GridBagConstraints.REMAINDER; //end row makebutton(“Button7”, gridbag, c); c.gridwidth = 1;//reset to the default c.gridheight = 2; c.weighty = 1.0; makebutton(“Button8”, gridbag, c); c.weighty = 0.0;//reset to the default c.gridwidth = GridBagConstraints.REMAINDER; //end row c.gridheight = 1;//reset to the default makebutton(“Button9”, gridbag, c); makebutton(“Button10”, gridbag, c); setSize(300, 100);}
Using the Grid Bag Layout Engine, items can be associated with a plurality of constraints that operate to determine the positions and sizes of the items. For example, the GridBagConstraints.REMAINDER constraint operates to specify that an item be the last one in its row (for gridwidth) or column (for gridheight). The GridBagConstraints.RELATIVE constraint operates to specify that an item be the next to last one in its row (for gridwidth) or column (for gridheight). While the system of associating items with constraints to determine their positions useful in many respects, it ultimately leads to more complicated coding than is necessary for many GUIs, while at the same time burdening a system with extra computational costs and leading to less flexibility in adding items to a GUI at a later time.
In light of the aforementioned shortcomings in the art, a new API is desired that allows for simpler coding of tabular layouts. In addition, the API should maximize performance while minimizing the computational resources needed to generate tabular layouts.